home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 February / PCWFEB09.iso / Software / Resources / Chat & Communication / Digsby build 37 / digsby_setup.exe / lib / ZSI / generate / wsdl2dispatch.pyo (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2008-10-13  |  13.0 KB  |  370 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.5)
  3.  
  4. import inspect
  5. from cStringIO import StringIO
  6. import ZSI
  7. import string
  8. import sys
  9. import getopt
  10. import urlparse
  11. import types
  12. import warnings
  13. from ZSI.wstools import WSDLTools
  14. from ZSI.ServiceContainer import ServiceSOAPBinding, SimpleWSResource, WSAResource
  15. from ZSI.generate import WsdlGeneratorError, Wsdl2PythonError
  16. from utility import TextProtect, GetModuleBaseNameFromWSDL, NCName_to_ClassName, GetPartsSubNames, TextProtectAttributeName
  17. from containers import BindingDescription
  18. from wsdl2python import MessageWriter, WriteServiceModule, MessageTypecodeContainer, SchemaDescription
  19.  
  20. rsplit = lambda x, sep: (x[:x.rfind(sep)], x[x.rfind(sep) + 1:])
  21. if sys.version_info[0:2] == (2, 4, 0, 'final', 0)[0:2]:
  22.     
  23.     rsplit = lambda x, sep: x.rsplit(sep, 1)
  24.  
  25.  
  26. class SOAPService:
  27.     
  28.     def __init__(self, service):
  29.         self.classdef = StringIO()
  30.         self.initdef = StringIO()
  31.         self.location = ''
  32.         self.methods = []
  33.  
  34.     
  35.     def newMethod(self):
  36.         self.methods.append(StringIO())
  37.         return self.methods[-1]
  38.  
  39.  
  40.  
  41. class ServiceModuleWriter:
  42.     indent = '    '
  43.     server_module_suffix = '_server'
  44.     func_aname = TextProtectAttributeName
  45.     func_aname = staticmethod(func_aname)
  46.     separate_messages = False
  47.     
  48.     def __init__(self, base = ServiceSOAPBinding, prefix = 'soap', service_class = SOAPService):
  49.         if inspect.isclass(base):
  50.             self.base_class_name = base.__name__
  51.             self.base_module_name = inspect.getmodule(base).__name__
  52.         else:
  53.             (self.base_module_name, self.base_class_name) = base.rsplit('.', 1)
  54.         self.wsdl = None
  55.         self.method_prefix = prefix
  56.         self._service_class = SOAPService
  57.         self.header = None
  58.         self.imports = None
  59.         self.messages = []
  60.         self._services = None
  61.         self.types_module_path = None
  62.         self.types_module_name = None
  63.         self.messages_module_name = None
  64.  
  65.     
  66.     def reset(self):
  67.         self.header = StringIO()
  68.         self.imports = StringIO()
  69.         self.message = []
  70.         self._services = { }
  71.  
  72.     
  73.     def getIndent(self, level = 1):
  74.         return self.indent * level
  75.  
  76.     
  77.     def getMethodName(self, method):
  78.         return '%s_%s' % (self.method_prefix, TextProtect(method))
  79.  
  80.     
  81.     def getClassName(self, name):
  82.         return NCName_to_ClassName(name)
  83.  
  84.     
  85.     def setTypesModuleName(self, name):
  86.         self.types_module_name = name
  87.  
  88.     setClientModuleName = setTypesModuleName
  89.     
  90.     def getTypesModuleName(self):
  91.         if self.types_module_name is not None:
  92.             return self.types_module_name
  93.         
  94.         wsm = WriteServiceModule(self.wsdl)
  95.         return wsm.getTypesModuleName()
  96.  
  97.     
  98.     def getServiceModuleName(self):
  99.         name = GetModuleBaseNameFromWSDL(self.wsdl)
  100.         if not name:
  101.             raise WsdlGeneratorError, 'could not determine a service name'
  102.         
  103.         if self.server_module_suffix is None:
  104.             return name
  105.         
  106.         return '%s%s' % (name, self.server_module_suffix)
  107.  
  108.     
  109.     def getTypesModulePath(self):
  110.         return self.types_module_path
  111.  
  112.     getClientModulePath = getTypesModulePath
  113.     
  114.     def setTypesModulePath(self, path):
  115.         self.types_module_path = path
  116.  
  117.     setClientModulePath = setTypesModulePath
  118.     
  119.     def setUpClassDef(self, service):
  120.         s = self._services[service.name].classdef
  121.         print >>s, 'class %s(%s):' % (self.getClassName(service.name), self.base_class_name)
  122.         print >>s, '%ssoapAction = {}' % self.getIndent(level = 1)
  123.         print >>s, '%sroot = {}' % self.getIndent(level = 1)
  124.  
  125.     
  126.     def setUpImports(self):
  127.         i = self.imports
  128.         print >>i, 'from ZSI.schema import GED, GTD'
  129.         print >>i, 'from ZSI.TCcompound import ComplexType, Struct'
  130.         module = self.getTypesModuleName()
  131.         package = self.getTypesModulePath()
  132.         if package:
  133.             module = '%s.%s' % (package, module)
  134.         
  135.         print >>i, 'from %s import *' % module
  136.         print >>i, 'from %s import %s' % (self.base_module_name, self.base_class_name)
  137.  
  138.     
  139.     def setUpInitDef(self, service):
  140.         sd = self._services[service.name]
  141.         d = sd.initdef
  142.         if sd.location is not None:
  143.             (scheme, netloc, path, params, query, fragment) = urlparse.urlparse(sd.location)
  144.             print >>d, "%sdef __init__(self, post='%s', **kw):" % (self.getIndent(level = 1), path)
  145.         else:
  146.             print >>d, '%sdef __init__(self, post, **kw):' % self.getIndent(level = 1)
  147.         if self.base_module_name == inspect.getmodule(ServiceSOAPBinding).__name__:
  148.             print >>d, '%s%s.__init__(self, post)' % (self.getIndent(level = 2), self.base_class_name)
  149.             return None
  150.         
  151.         print >>d, '%s%s.__init__(self)' % (self.getIndent(level = 2), self.base_class_name)
  152.  
  153.     
  154.     def mangle(self, name):
  155.         return TextProtect(name)
  156.  
  157.     
  158.     def getAttributeName(self, name):
  159.         return self.func_aname(name)
  160.  
  161.     
  162.     def setUpMethods(self, port):
  163.         sd = self._services.get(port.getService().name)
  164.         binding = port.getBinding()
  165.         portType = port.getPortType()
  166.         action_in = ''
  167.         for bop in binding.operations:
  168.             
  169.             try:
  170.                 op = portType.operations[bop.name]
  171.             except KeyError:
  172.                 ex = None
  173.                 raise WsdlGeneratorError, 'Port(%s) PortType(%s) missing operation(%s) defined in Binding(%s)' % (port.name, portType.name, bop.name, binding.name)
  174.  
  175.             for ext in bop.extensions:
  176.                 if isinstance(ext, WSDLTools.SoapOperationBinding):
  177.                     action_in = ext.soapAction
  178.                     break
  179.                     continue
  180.             
  181.             msgin = op.getInputMessage()
  182.             msgin_name = TextProtect(msgin.name)
  183.             method_name = self.getMethodName(op.name)
  184.             m = sd.newMethod()
  185.             print >>m, '%sdef %s(self, ps, **kw):' % (self.getIndent(level = 1), method_name)
  186.             if msgin is not None:
  187.                 print >>m, '%srequest = ps.Parse(%s.typecode)' % (self.getIndent(level = 2), msgin_name)
  188.             else:
  189.                 print >>m, '%s# NO input' % self.getIndent(level = 2)
  190.             msgout = op.getOutputMessage()
  191.             if msgout is not None:
  192.                 msgout_name = TextProtect(msgout.name)
  193.                 print >>m, '%sreturn request,%s()' % (self.getIndent(level = 2), msgout_name)
  194.             else:
  195.                 print >>m, '%s# NO output' % self.getIndent(level = 2)
  196.                 print >>m, '%sreturn request,None' % self.getIndent(level = 2)
  197.             print >>m, ''
  198.             print >>m, "%ssoapAction['%s'] = '%s'" % (self.getIndent(level = 1), action_in, method_name)
  199.             print >>m, "%sroot[(%s.typecode.nspname,%s.typecode.pname)] = '%s'" % (self.getIndent(level = 1), msgin_name, msgin_name, method_name)
  200.         
  201.  
  202.     
  203.     def setUpHeader(self):
  204.         print >>self.header, '#' * 50
  205.         print >>self.header, '# file: %s.py' % self.getServiceModuleName()
  206.         print >>self.header, '#'
  207.         print >>self.header, '# skeleton generated by "%s"' % self.__class__
  208.         print >>self.header, '#      %s' % ' '.join(sys.argv)
  209.         print >>self.header, '#'
  210.         print >>self.header, '#' * 50
  211.  
  212.     
  213.     def write(self, fd = sys.stdout):
  214.         print >>fd, self.header.getvalue()
  215.         print >>fd, self.imports.getvalue()
  216.         print >>fd, '# Messages ',
  217.         for m in self.messages:
  218.             print >>fd, m
  219.         
  220.         print >>fd, ''
  221.         print >>fd, ''
  222.         print >>fd, '# Service Skeletons'
  223.         for k, v in self._services.items():
  224.             print >>fd, v.classdef.getvalue()
  225.             print >>fd, v.initdef.getvalue()
  226.             for s in v.methods:
  227.                 print >>fd, s.getvalue()
  228.             
  229.         
  230.  
  231.     
  232.     def fromWSDL(self, wsdl):
  233.         if len(wsdl.services) == 0:
  234.             raise WsdlGeneratorError, 'No service defined'
  235.         
  236.         self.reset()
  237.         self.wsdl = wsdl
  238.         self.setUpHeader()
  239.         self.setUpImports()
  240.         for service in wsdl.services:
  241.             sd = self._service_class(service.name)
  242.             self._services[service.name] = sd
  243.             for port in service.ports:
  244.                 desc = BindingDescription(wsdl = wsdl)
  245.                 
  246.                 try:
  247.                     desc.setUp(port.getBinding())
  248.                 except Wsdl2PythonError:
  249.                     ex = None
  250.                     continue
  251.  
  252.                 for soc in desc.operations:
  253.                     if not soc.hasInput():
  254.                         continue
  255.                     
  256.                     self.messages.append(MessageWriter())
  257.                     self.messages[-1].setUp(soc, port, input = True)
  258.                     if soc.hasOutput():
  259.                         self.messages.append(MessageWriter())
  260.                         self.messages[-1].setUp(soc, port, input = False)
  261.                         continue
  262.                 
  263.                 for e in port.extensions:
  264.                     if isinstance(e, WSDLTools.SoapAddressBinding):
  265.                         sd.location = e.location
  266.                         continue
  267.                 
  268.                 self.setUpMethods(port)
  269.             
  270.             self.setUpClassDef(service)
  271.             self.setUpInitDef(service)
  272.         
  273.  
  274.  
  275.  
  276. class WSAServiceModuleWriter(ServiceModuleWriter):
  277.     
  278.     def __init__(self, base = WSAResource, prefix = 'wsa', service_class = SOAPService, strict = True):
  279.         ServiceModuleWriter.__init__(self, base, prefix, service_class)
  280.         self.strict = strict
  281.  
  282.     
  283.     def createMethodBody(msgInName, msgOutName, **kw):
  284.         body = []
  285.         if msgInName is not None:
  286.             body.append('request = ps.Parse(%s.typecode)' % msgInName)
  287.         
  288.         if msgOutName is not None:
  289.             body.append('return request,%s()' % msgOutName)
  290.         else:
  291.             body.append('return request,None')
  292.         return tuple(body)
  293.  
  294.     createMethodBody = staticmethod(createMethodBody)
  295.     
  296.     def setUpClassDef(self, service):
  297.         s = self._services[service.name].classdef
  298.         print >>s, 'class %s(%s):' % (self.getClassName(service.name), self.base_class_name)
  299.         print >>s, '%ssoapAction = {}' % self.getIndent(level = 1)
  300.         print >>s, '%swsAction = {}' % self.getIndent(level = 1)
  301.         print >>s, '%sroot = {}' % self.getIndent(level = 1)
  302.  
  303.     
  304.     def setUpMethods(self, port):
  305.         binding = port.getBinding()
  306.         portType = port.getPortType()
  307.         service = port.getService()
  308.         s = self._services[service.name]
  309.         for bop in binding.operations:
  310.             
  311.             try:
  312.                 op = portType.operations[bop.name]
  313.             except KeyError:
  314.                 ex = None
  315.                 raise WsdlGeneratorError, 'Port(%s) PortType(%s) missing operation(%s) defined in Binding(%s)' % (port.name, portType.name, op.name, binding.name)
  316.  
  317.             soap_action = None
  318.             wsaction_in = None
  319.             wsaction_out = None
  320.             if op.input is not None:
  321.                 wsaction_in = op.getInputAction()
  322.             
  323.             if op.output is not None:
  324.                 wsaction_out = op.getOutputAction()
  325.             
  326.             for ext in bop.extensions:
  327.                 if isinstance(ext, WSDLTools.SoapOperationBinding) is False:
  328.                     continue
  329.                 
  330.                 soap_action = ext.soapAction
  331.                 if not soap_action:
  332.                     break
  333.                 
  334.                 if wsaction_in is None:
  335.                     break
  336.                 
  337.                 if wsaction_in == soap_action:
  338.                     break
  339.                 
  340.                 if self.strict is False:
  341.                     warnings.warn('Port(%s) operation(%s) in Binding(%s) soapAction(%s) != WS-Action(%s)' % (port.name, op.name, binding.name, soap_action, wsaction_in))
  342.                     break
  343.                 
  344.                 raise WsdlGeneratorError, 'Port(%s) operation(%s) in Binding(%s) soapAction(%s) MUST match WS-Action(%s)' % (port.name, op.name, binding.name, soap_action, wsaction_in)
  345.             
  346.             method_name = self.getMethodName(op.name)
  347.             m = s.newMethod()
  348.             print >>m, '%sdef %s(self, ps, address):' % (self.getIndent(level = 1), method_name)
  349.             msgin_name = None
  350.             msgout_name = None
  351.             msgin = op.getInputMessage()
  352.             msgout = op.getOutputMessage()
  353.             if msgin is not None:
  354.                 msgin_name = TextProtect(msgin.name)
  355.             
  356.             if msgout is not None:
  357.                 msgout_name = TextProtect(msgout.name)
  358.             
  359.             indent = self.getIndent(level = 2)
  360.             for l in self.createMethodBody(msgin_name, msgout_name):
  361.                 print >>m, indent + l
  362.             
  363.             print >>m, ''
  364.             print >>m, "%ssoapAction['%s'] = '%s'" % (self.getIndent(level = 1), wsaction_in, method_name)
  365.             print >>m, "%swsAction['%s'] = '%s'" % (self.getIndent(level = 1), method_name, wsaction_out)
  366.             print >>m, "%sroot[(%s.typecode.nspname,%s.typecode.pname)] = '%s'" % (self.getIndent(level = 1), msgin_name, msgin_name, method_name)
  367.         
  368.  
  369.  
  370.